package com.atwy.java8;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import static java.util.stream.Collectors.toList;

/**
 * @Author: 小王子火
 * @Date: 2022/4/2
 */
public class NormalText {
    public static void main(String[] args) {
        List<String> apples = new ArrayList<>();

        apples.add("adg");
        apples.add("ab");
        apples.add("ac");
        apples.add("a");
        apples.add("c");
        apples.add("d");

        List<String> a = apples.stream().filter((String str) -> str.indexOf("a") > -1).collect(toList());
        a.sort((v1,v2)-> v2.length()-v1.length());

        System.out.println(a);

        int num = 1024;
        Runnable r = ()-> System.out.println("r->"+ num);
        r.run();

        System.out.println("研究flatMap");
        // 入参{"hello","world"}，想要得到String[] result = {"h","e","l","o","w","r","d"};
        List<String> words = Arrays.asList("hello","world");
        // Arrays::stream
        String[] testArrays ={"hello","world"};
        Stream<String> stream = Arrays.stream(testArrays);

        // 不符合要求
        List<Stream<String>> collect = words.stream()
                .map(word -> word.split(""))
                // 下面的map会遍历上面map生成的(String[])[],也就是
                // { [ ["h"],["e"],["l"],["l"],["o"] ] , [ ["w"],["o"],["r"],["l"],["d"] ]}
                //    Arrays.stream会将String[] 变成Stream<String>
                // 所以下面的map将 内存每个单独的流组成的最外层的流即 Stream<Steam<String>>
                .map(Arrays::stream)
                .distinct()
                .collect(Collectors.toList());

        // 使用flatMap
        List<String> result = words.stream()
                .map(word -> word.split(""))
                // flatMap 将每个单独的流扁平化最为外层流的内容，
                // 即将Stream<Steam<String>> 变成 Stream<String>
                .flatMap(Arrays::stream)
                .distinct()
                .collect(Collectors.toList());
        // 使用flatMap方法的效果是，各个数组并不是分别映射成一个流，而是映射成流的内容。所
        // 有使用map(Arrays::stream)时生成的单个流都被合并起来，即扁平化为一个流。
        // flatmap方法让你把一个流中的每个值都换成另一个流，然后把所有的流连接起来成为一个流
        System.out.println(result);

        System.out.println("研究reduce");
        List<Integer> numbers = Arrays.asList(1,5,4,2,3);
        Integer sum = numbers.stream()
                // reduce入参有两个
                // 第一个参数，初始值
                // 第二个参数Lambda，行为参数，
                .reduce(0, (v1, v2) -> {
                    // 看下v1，v2分别是什么
                    System.out.println("v1="+v1+",v2="+v2);
                    return v1 + v2;
                });
        // 从计算过程可以看出reduce的归约作用（reduce也可以没有初始值，这样返回的就是Optional<T>）
        // v1=0,v2=1
        // v1=1,v2=5
        // v1=6,v2=4
        // v1=10,v2=2
        // v1=12,v2=3
        System.out.println("reduce计算"+numbers+"之和 = "+sum);
        // 求最大值，reduce没有初始值，所以结果有可能为空，所以返回Optional
        Optional<Integer> max = numbers.stream().reduce(Integer::max);
        System.out.println("reduce计算"+numbers+"最大值 = "+max.get());

    }
}
